ไปป์ไลน์ Async Iterator ของ JavaScript: โซ่การประมวลผลสตรีม

ในโลกของการพัฒนา JavaScript สมัยใหม่ การจัดการชุดข้อมูลขนาดใหญ่และการทำงานแบบอะซิงโครนัสอย่างมีประสิทธิภาพเป็นสิ่งสำคัญยิ่ง Async iterators และไปป์ไลน์เป็นกลไกอันทรงพลังในการประมวลผลสตรีมข้อมูลแบบอะซิงโครนัส โดยทำการแปลงและจัดการข้อมูลในลักษณะที่ไม่ปิดกั้น (non-blocking) แนวทางนี้มีประโยชน์อย่างยิ่งสำหรับการสร้างแอปพลิเคชันที่ปรับขนาดได้และตอบสนองได้ดี ซึ่งต้องจัดการกับข้อมูลแบบเรียลไทม์ ไฟล์ขนาดใหญ่ หรือการแปลงข้อมูลที่ซับซ้อน

Async Iterators คืออะไร?

Async iterators เป็นฟีเจอร์สมัยใหม่ของ JavaScript ที่ช่วยให้คุณสามารถวนซ้ำค่าต่างๆ ในลำดับแบบอะซิงโครนัสได้ มีลักษณะคล้ายกับ iterators ทั่วไป แต่แทนที่จะส่งคืนค่าโดยตรง มันจะส่งคืน promise ที่จะ resolve เป็นค่าถัดไปในลำดับ ลักษณะที่เป็นอะซิงโครนัสนี้ทำให้เหมาะอย่างยิ่งสำหรับการจัดการกับแหล่งข้อมูลที่ผลิตข้อมูลออกมาเมื่อเวลาผ่านไป เช่น สตรีมเครือข่าย การอ่านไฟล์ หรือข้อมูลเซ็นเซอร์

async iterator มีเมธอด next() ที่ส่งคืน promise ซึ่ง promise นี้จะ resolve เป็นอ็อบเจ็กต์ที่มีสองคุณสมบัติ:

• value: ค่าถัดไปในลำดับ
• done: ค่าบูลีนที่ระบุว่าการวนซ้ำเสร็จสิ้นแล้วหรือไม่

นี่คือตัวอย่างง่ายๆ ของ async iterator ที่สร้างลำดับของตัวเลข:

async function* numberGenerator(limit) {
  for (let i = 0; i < limit; i++) {
    await new Promise(resolve => setTimeout(resolve, 100)); // จำลองการทำงานแบบอะซิงโครนัส
    yield i;
  }
}

(async () => {
  for await (const number of numberGenerator(5)) {
    console.log(number);
  }
})();

ในตัวอย่างนี้ numberGenerator เป็นฟังก์ชัน async generator (ระบุด้วยไวยากรณ์ async function*) ซึ่งจะ yield ลำดับของตัวเลขตั้งแต่ 0 ถึง limit - 1 และลูป for await...of จะวนซ้ำค่าที่ผลิตโดย generator แบบอะซิงโครนัส

การทำความเข้าใจ Async Iterators ในสถานการณ์จริง

Async iterators ทำงานได้ดีเยี่ยมเมื่อต้องจัดการกับการดำเนินการที่เกี่ยวข้องกับการรอคอยโดยธรรมชาติ เช่น:

• การอ่านไฟล์ขนาดใหญ่: แทนที่จะโหลดไฟล์ทั้งไฟล์เข้ามาในหน่วยความจำ async iterator สามารถอ่านไฟล์ทีละบรรทัดหรือทีละส่วน (chunk) และประมวลผลแต่ละส่วนเมื่อพร้อมใช้งาน ซึ่งช่วยลดการใช้หน่วยความจำและปรับปรุงการตอบสนอง ลองนึกภาพการประมวลผลไฟล์ล็อกขนาดใหญ่จากเซิร์ฟเวอร์ในโตเกียว คุณสามารถใช้ async iterator เพื่ออ่านไฟล์เป็นส่วนๆ แม้ว่าการเชื่อมต่อเครือข่ายจะช้าก็ตาม
• การสตรีมข้อมูลจาก API: API หลายตัวให้ข้อมูลในรูปแบบสตรีมมิ่ง async iterator สามารถรับสตรีมนี้และประมวลผลข้อมูลเมื่อมาถึง แทนที่จะต้องรอให้ดาวน์โหลดการตอบกลับทั้งหมดเสร็จสิ้น ตัวอย่างเช่น API ข้อมูลทางการเงินที่สตรีมราคาหุ้น
• ข้อมูลเซ็นเซอร์แบบเรียลไทม์: อุปกรณ์ IoT มักจะสร้างสตรีมข้อมูลเซ็นเซอร์อย่างต่อเนื่อง สามารถใช้ Async iterators เพื่อประมวลผลข้อมูลนี้แบบเรียลไทม์ และสั่งให้ทำงานตามเหตุการณ์หรือเกณฑ์ที่กำหนด ลองพิจารณาเซ็นเซอร์ตรวจอากาศในอาร์เจนตินาที่สตรีมข้อมูลอุณหภูมิ async iterator สามารถประมวลผลข้อมูลและส่งการแจ้งเตือนหากอุณหภูมิลดลงต่ำกว่าจุดเยือกแข็ง

Async Iterator Pipeline คืออะไร?

ไปป์ไลน์ async iterator คือลำดับของ async iterators ที่เชื่อมต่อกันเพื่อประมวลผลสตรีมข้อมูล iterator แต่ละตัวในไปป์ไลน์จะทำการแปลงหรือดำเนินการเฉพาะกับข้อมูล ก่อนที่จะส่งต่อไปยัง iterator ถัดไปในโซ่ ซึ่งช่วยให้คุณสามารถสร้างเวิร์กโฟลว์การประมวลผลข้อมูลที่ซับซ้อนในลักษณะที่เป็นโมดูลและนำกลับมาใช้ใหม่ได้

แนวคิดหลักคือการแบ่งงานประมวลผลที่ซับซ้อนออกเป็นขั้นตอนย่อยๆ ที่จัดการได้ง่ายขึ้น โดยแต่ละขั้นตอนจะแทนด้วย async iterator จากนั้น iterators เหล่านี้จะถูกเชื่อมต่อกันเป็นไปป์ไลน์ ซึ่งผลลัพธ์ของ iterator หนึ่งจะกลายเป็นอินพุตของ iterator ถัดไป

ลองนึกภาพเหมือนสายพานการผลิต: แต่ละสถานีจะทำงานเฉพาะอย่างกับผลิตภัณฑ์ที่เคลื่อนที่ไปตามสายพาน ในกรณีของเรา ผลิตภัณฑ์คือสตรีมข้อมูล และสถานีคือ async iterators

การสร้าง Async Iterator Pipeline

เรามาสร้างตัวอย่างง่ายๆ ของไปป์ไลน์ async iterator ที่:

1. สร้างลำดับของตัวเลข
2. กรองตัวเลขคี่ออก
3. นำตัวเลขคู่ที่เหลือมายกกำลังสอง
4. แปลงตัวเลขที่ยกกำลังสองเป็นสตริง

async function* numberGenerator(limit) {
  for (let i = 0; i < limit; i++) {
    yield i;
  }
}

async function* filter(source, predicate) {
  for await (const item of source) {
    if (predicate(item)) {
      yield item;
    }
  }
}

async function* map(source, transform) {
  for await (const item of source) {
    yield transform(item);
  }
}

(async () => {
  const numbers = numberGenerator(10);
  const evenNumbers = filter(numbers, (number) => number % 2 === 0);
  const squaredNumbers = map(evenNumbers, (number) => number * number);
  const stringifiedNumbers = map(squaredNumbers, (number) => number.toString());

  for await (const numberString of stringifiedNumbers) {
    console.log(numberString);
  }
})();

ในตัวอย่างนี้:

• numberGenerator สร้างลำดับของตัวเลขตั้งแต่ 0 ถึง 9
• filter กรองตัวเลขคี่ออก เหลือไว้แต่ตัวเลขคู่
• map ยกกำลังสองตัวเลขคู่แต่ละตัว
• map แปลงตัวเลขที่ยกกำลังสองแต่ละตัวเป็นสตริง

ลูป for await...of จะวนซ้ำ async iterator ตัวสุดท้ายในไปป์ไลน์ (stringifiedNumbers) และพิมพ์ตัวเลขที่ยกกำลังสองแต่ละตัวในรูปแบบสตริงออกมาที่คอนโซล

ประโยชน์หลักของการใช้ Async Iterator Pipelines

ไปป์ไลน์ async iterator มีข้อดีที่สำคัญหลายประการ:

• ประสิทธิภาพที่ดีขึ้น: ด้วยการประมวลผลข้อมูลแบบอะซิงโครนัสและเป็นส่วนๆ ไปป์ไลน์สามารถปรับปรุงประสิทธิภาพได้อย่างมาก โดยเฉพาะเมื่อต้องจัดการกับชุดข้อมูลขนาดใหญ่หรือแหล่งข้อมูลที่ช้า ซึ่งช่วยป้องกันการบล็อกเธรดหลักและรับประกันประสบการณ์ผู้ใช้ที่ตอบสนองได้ดีขึ้น
• ลดการใช้หน่วยความจำ: ไปป์ไลน์ประมวลผลข้อมูลในลักษณะสตรีมมิ่ง หลีกเลี่ยงความจำเป็นในการโหลดชุดข้อมูลทั้งหมดลงในหน่วยความจำในคราวเดียว ซึ่งเป็นสิ่งสำคัญสำหรับแอปพลิเคชันที่จัดการกับไฟล์ขนาดใหญ่มากหรือสตรีมข้อมูลต่อเนื่อง
• ความเป็นโมดูลและการนำกลับมาใช้ใหม่: iterator แต่ละตัวในไปป์ไลน์จะทำงานเฉพาะอย่าง ทำให้โค้ดเป็นโมดูลและเข้าใจง่ายขึ้น สามารถนำ iterators กลับมาใช้ใหม่ในไปป์ไลน์ต่างๆ เพื่อทำการแปลงแบบเดียวกันกับสตรีมข้อมูลที่แตกต่างกันได้
• เพิ่มความสามารถในการอ่าน: ไปป์ไลน์แสดงเวิร์กโฟลว์การประมวลผลข้อมูลที่ซับซ้อนในลักษณะที่ชัดเจนและรัดกุม ทำให้โค้ดอ่านและบำรุงรักษาง่ายขึ้น รูปแบบการเขียนโปรแกรมเชิงฟังก์ชันส่งเสริม immutability และหลีกเลี่ยง side effects ซึ่งช่วยปรับปรุงคุณภาพโค้ดให้ดียิ่งขึ้น
• การจัดการข้อผิดพลาด: การจัดการข้อผิดพลาดที่แข็งแกร่งในไปป์ไลน์เป็นสิ่งสำคัญ คุณสามารถครอบแต่ละขั้นตอนด้วยบล็อก try/catch หรือใช้ iterator จัดการข้อผิดพลาดโดยเฉพาะในโซ่เพื่อจัดการปัญหาที่อาจเกิดขึ้นได้อย่างราบรื่น

เทคนิคไปป์ไลน์ขั้นสูง

นอกเหนือจากตัวอย่างพื้นฐานข้างต้น คุณสามารถใช้เทคนิคที่ซับซ้อนมากขึ้นเพื่อสร้างไปป์ไลน์ที่ซับซ้อนได้:

• การบัฟเฟอร์ (Buffering): บางครั้งคุณอาจต้องสะสมข้อมูลจำนวนหนึ่งก่อนที่จะประมวลผล คุณสามารถสร้าง iterator ที่บัฟเฟอร์ข้อมูลจนกว่าจะถึงเกณฑ์ที่กำหนด จากนั้นจึงปล่อยข้อมูลที่บัฟเฟอร์ออกมาเป็นก้อนเดียว ซึ่งมีประโยชน์สำหรับการประมวลผลแบบแบตช์หรือเพื่อทำให้สตรีมข้อมูลที่มีอัตราไม่คงที่ราบรื่นขึ้น
• Debouncing และ Throttling: เทคนิคเหล่านี้สามารถใช้เพื่อควบคุมอัตราการประมวลผลข้อมูล ป้องกันการทำงานหนักเกินไปและปรับปรุงประสิทธิภาพ Debouncing จะชะลอการประมวลผลจนกว่าจะผ่านไประยะเวลาหนึ่งหลังจากข้อมูลรายการสุดท้ายมาถึง Throttling จะจำกัดอัตราการประมวลผลไว้ที่จำนวนรายการสูงสุดต่อหน่วยเวลา
• การจัดการข้อผิดพลาด (Error Handling): การจัดการข้อผิดพลาดที่แข็งแกร่งเป็นสิ่งจำเป็นสำหรับไปป์ไลน์ใดๆ คุณสามารถใช้บล็อก try/catch ภายใน iterator แต่ละตัวเพื่อดักจับและจัดการข้อผิดพลาด หรืออีกทางหนึ่งคือสร้าง iterator จัดการข้อผิดพลาดโดยเฉพาะที่ดักจับข้อผิดพลาดและดำเนินการที่เหมาะสม เช่น การบันทึกข้อผิดพลาดหรือการลองดำเนินการใหม่
• แรงดันย้อนกลับ (Backpressure): การจัดการแรงดันย้อนกลับเป็นสิ่งสำคัญเพื่อให้แน่ใจว่าไปป์ไลน์จะไม่ถูกท่วมท้นด้วยข้อมูล หาก iterator ปลายทางช้ากว่า iterator ต้นทาง iterator ต้นทางอาจต้องชะลออัตราการผลิตข้อมูลลง ซึ่งสามารถทำได้โดยใช้เทคนิคต่างๆ เช่น การควบคุมการไหล (flow control) หรือไลบรารี reactive programming

ตัวอย่างการใช้งาน Async Iterator Pipelines ในทางปฏิบัติ

เรามาดูตัวอย่างที่เป็นประโยชน์เพิ่มเติมเกี่ยวกับวิธีใช้ไปป์ไลน์ async iterator ในสถานการณ์จริงกัน:

ตัวอย่างที่ 1: การประมวลผลไฟล์ CSV ขนาดใหญ่

สมมติว่าคุณมีไฟล์ CSV ขนาดใหญ่ที่เก็บข้อมูลลูกค้าที่คุณต้องประมวลผล คุณสามารถใช้ไปป์ไลน์ async iterator เพื่ออ่านไฟล์ แยกวิเคราะห์แต่ละบรรทัด และทำการตรวจสอบและแปลงข้อมูล

const fs = require('fs');
const readline = require('readline');

async function* readFileLines(filePath) {
  const fileStream = fs.createReadStream(filePath);

  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  for await (const line of rl) {
    yield line;
  }
}

async function* parseCSV(source) {
  for await (const line of source) {
    const values = line.split(',');
    // ทำการตรวจสอบและแปลงข้อมูลที่นี่
    yield values;
  }
}

(async () => {
  const filePath = 'path/to/your/customer_data.csv';
  const lines = readFileLines(filePath);
  const parsedData = parseCSV(lines);

  for await (const row of parsedData) {
    console.log(row);
  }
})();

ตัวอย่างนี้อ่านไฟล์ CSV ทีละบรรทัดโดยใช้ readline แล้วแยกวิเคราะห์แต่ละบรรทัดเป็นอาร์เรย์ของค่า คุณสามารถเพิ่ม iterators เพิ่มเติมเข้าไปในไปป์ไลน์เพื่อทำการตรวจสอบ ทำความสะอาด และแปลงข้อมูลต่อไปได้

ตัวอย่างที่ 2: การใช้งาน Streaming API

API หลายตัวให้ข้อมูลในรูปแบบสตรีมมิ่ง เช่น Server-Sent Events (SSE) หรือ WebSockets คุณสามารถใช้ไปป์ไลน์ async iterator เพื่อรับสตรีมเหล่านี้และประมวลผลข้อมูลแบบเรียลไทม์

const fetch = require('node-fetch');

async function* fetchStream(url) {
  const response = await fetch(url);
  const reader = response.body.getReader();

  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        return;
      }
      yield new TextDecoder().decode(value);
    }
  } finally {
    reader.releaseLock();
  }
}

async function* processData(source) {
  for await (const chunk of source) {
    // ประมวลผลชิ้นส่วนข้อมูลที่นี่
    yield chunk;
  }
}

(async () => {
  const url = 'https://api.example.com/data/stream';
  const stream = fetchStream(url);
  const processedData = processData(stream);

  for await (const data of processedData) {
    console.log(data);
  }
})();

ตัวอย่างนี้ใช้ fetch API เพื่อดึงข้อมูลการตอบกลับแบบสตรีมมิ่งแล้วอ่านส่วนเนื้อหา (body) ของการตอบกลับทีละส่วน คุณสามารถเพิ่ม iterators เข้าไปในไปป์ไลน์เพื่อแยกวิเคราะห์ข้อมูล แปลงข้อมูล และดำเนินการอื่นๆ ได้

ตัวอย่างที่ 3: การประมวลผลข้อมูลเซ็นเซอร์แบบเรียลไทม์

ดังที่กล่าวไว้ก่อนหน้านี้ ไปป์ไลน์ async iterator เหมาะอย่างยิ่งสำหรับการประมวลผลข้อมูลเซ็นเซอร์แบบเรียลไทม์จากอุปกรณ์ IoT คุณสามารถใช้ไปป์ไลน์เพื่อกรอง รวบรวม และวิเคราะห์ข้อมูลเมื่อมาถึง

// สมมติว่าคุณมีฟังก์ชันที่ปล่อยข้อมูลเซ็นเซอร์ออกมาเป็น async iterable
async function* sensorDataStream() {
  // จำลองการปล่อยข้อมูลเซ็นเซอร์
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 500));
    yield Math.random() * 100; // จำลองการอ่านค่าอุณหภูมิ
  }
}

async function* filterOutliers(source, threshold) {
  for await (const reading of source) {
    if (reading > threshold) {
      yield reading;
    }
  }
}

async function* calculateAverage(source, windowSize) {
  let buffer = [];
  for await (const reading of source) {
    buffer.push(reading);
    if (buffer.length > windowSize) {
      buffer.shift();
    }
    if (buffer.length === windowSize) {
      const average = buffer.reduce((sum, val) => sum + val, 0) / windowSize;
      yield average;
    }
  }
}

(async () => {
  const sensorData = sensorDataStream();
  const filteredData = filterOutliers(sensorData, 90); // กรองค่าที่อ่านได้ที่สูงกว่า 90 ออก
  const averageTemperature = calculateAverage(filteredData, 5); // คำนวณค่าเฉลี่ยจาก 5 ค่าที่อ่านได้

  for await (const average of averageTemperature) {
    console.log(`Average Temperature: ${average.toFixed(2)}`);
  }
})();

ตัวอย่างนี้จำลองสตรีมข้อมูลเซ็นเซอร์แล้วใช้ไปป์ไลน์เพื่อกรองค่าที่ผิดปกติออกและคำนวณค่าเฉลี่ยเคลื่อนที่ของอุณหภูมิ ซึ่งช่วยให้คุณสามารถระบุแนวโน้มและความผิดปกติในข้อมูลเซ็นเซอร์ได้

ไลบรารีและเครื่องมือสำหรับ Async Iterator Pipelines

แม้ว่าคุณจะสามารถสร้างไปป์ไลน์ async iterator โดยใช้ JavaScript ธรรมดาได้ แต่ก็มีไลบรารีและเครื่องมือหลายตัวที่สามารถทำให้กระบวนการง่ายขึ้นและมีฟีเจอร์เพิ่มเติม:

• IxJS (Reactive Extensions for JavaScript): IxJS เป็นไลบรารีที่มีประสิทธิภาพสำหรับการเขียนโปรแกรมเชิงรีแอกทีฟใน JavaScript มีชุดโอเปอเรเตอร์ที่หลากหลายสำหรับการสร้างและจัดการ async iterables ทำให้การสร้างไปป์ไลน์ที่ซับซ้อนเป็นเรื่องง่าย
• Highland.js: Highland.js เป็นไลบรารีสตรีมมิ่งเชิงฟังก์ชันสำหรับ JavaScript มีชุดโอเปอเรเตอร์คล้ายกับ IxJS แต่เน้นความเรียบง่ายและใช้งานง่าย
• Node.js Streams API: Node.js มี Streams API ในตัวที่สามารถใช้สร้าง async iterators ได้ แม้ว่า Streams API จะเป็นระดับต่ำกว่า IxJS หรือ Highland.js แต่ก็ให้การควบคุมกระบวนการสตรีมมิ่งได้มากกว่า

ข้อผิดพลาดที่พบบ่อยและแนวทางปฏิบัติที่ดีที่สุด

แม้ว่าไปป์ไลน์ async iterator จะมีประโยชน์มากมาย แต่สิ่งสำคัญคือต้องตระหนักถึงข้อผิดพลาดที่พบบ่อยและปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุดเพื่อให้แน่ใจว่าไปป์ไลน์ของคุณมีความแข็งแกร่งและมีประสิทธิภาพ:

• หลีกเลี่ยงการดำเนินการที่ปิดกั้น (Blocking Operations): ตรวจสอบให้แน่ใจว่า iterator ทั้งหมดในไปป์ไลน์ดำเนินการแบบอะซิงโครนัสเพื่อหลีกเลี่ยงการบล็อกเธรดหลัก ใช้ฟังก์ชันอะซิงโครนัสและ promise เพื่อจัดการ I/O และงานที่ใช้เวลานานอื่นๆ
• จัดการข้อผิดพลาดอย่างเหมาะสม (Handle Errors Gracefully): นำการจัดการข้อผิดพลาดที่แข็งแกร่งมาใช้ใน iterator แต่ละตัวเพื่อดักจับและจัดการข้อผิดพลาดที่อาจเกิดขึ้น ใช้บล็อก try/catch หรือ iterator จัดการข้อผิดพลาดโดยเฉพาะเพื่อจัดการข้อผิดพลาด
• จัดการแรงดันย้อนกลับ (Manage Backpressure): นำการจัดการแรงดันย้อนกลับมาใช้เพื่อป้องกันไม่ให้ไปป์ไลน์ถูกท่วมท้นด้วยข้อมูล ใช้เทคนิคต่างๆ เช่น การควบคุมการไหล (flow control) หรือไลบรารี reactive programming เพื่อควบคุมการไหลของข้อมูล
• ปรับปรุงประสิทธิภาพ (Optimize Performance): วิเคราะห์โปรไฟล์ไปป์ไลน์ของคุณเพื่อระบุคอขวดด้านประสิทธิภาพและปรับปรุงโค้ดให้เหมาะสม ใช้เทคนิคต่างๆ เช่น การบัฟเฟอร์, debouncing, และ throttling เพื่อปรับปรุงประสิทธิภาพ
• ทดสอบอย่างละเอียด (Test Thoroughly): ทดสอบไปป์ไลน์ของคุณอย่างละเอียดเพื่อให้แน่ใจว่าทำงานได้อย่างถูกต้องภายใต้เงื่อนไขต่างๆ ใช้ unit tests และ integration tests เพื่อตรวจสอบการทำงานของ iterator แต่ละตัวและไปป์ไลน์โดยรวม

บทสรุป

ไปป์ไลน์ async iterator เป็นเครื่องมืออันทรงพลังสำหรับการสร้างแอปพลิเคชันที่ปรับขนาดได้และตอบสนองได้ดี ซึ่งต้องจัดการกับชุดข้อมูลขนาดใหญ่และการทำงานแบบอะซิงโครนัส ด้วยการแบ่งเวิร์กโฟลว์การประมวลผลข้อมูลที่ซับซ้อนออกเป็นขั้นตอนย่อยๆ ที่จัดการได้ง่ายขึ้น ไปป์ไลน์สามารถปรับปรุงประสิทธิภาพ ลดการใช้หน่วยความจำ และเพิ่มความสามารถในการอ่านโค้ดได้ ด้วยความเข้าใจพื้นฐานของ async iterators และไปป์ไลน์ และการปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุด คุณสามารถใช้ประโยชน์จากเทคนิคนี้เพื่อสร้างโซลูชันการประมวลผลข้อมูลที่มีประสิทธิภาพและแข็งแกร่งได้

การเขียนโปรแกรมแบบอะซิงโครนัสเป็นสิ่งจำเป็นในการพัฒนา JavaScript สมัยใหม่ และ async iterators กับไปป์ไลน์เป็นวิธีที่สะอาด มีประสิทธิภาพ และทรงพลังในการจัดการสตรีมข้อมูล ไม่ว่าคุณจะกำลังประมวลผลไฟล์ขนาดใหญ่ ใช้งาน streaming API หรือวิเคราะห์ข้อมูลเซ็นเซอร์แบบเรียลไทม์ ไปป์ไลน์ async iterator สามารถช่วยคุณสร้างแอปพลิเคชันที่ปรับขนาดได้และตอบสนองได้ดี ซึ่งตอบสนองความต้องการของโลกที่ขับเคลื่อนด้วยข้อมูลในปัจจุบัน